| 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203 |
11×
11×
11×
11×
11×
11×
11×
11×
11×
11×
11×
11×
11×
11×
11×
1×
189×
1×
10×
1×
43137×
1×
27×
21×
1×
9938×
1×
5×
5×
2×
5×
1×
24×
24×
1×
1×
94×
6×
88×
6×
82×
3×
79×
22×
22×
55×
94×
1×
55×
11×
11×
11×
11×
44×
44×
5×
39×
33×
1×
2×
2×
11×
5×
1×
22085×
1×
10×
10×
10×
1×
10×
10×
1×
1×
1×
10×
| 'use strict';
exports.__esModule = true;
exports.ensureNodeData = ensureNodeData;
exports.setNodeData = setNodeData;
exports.getNodeData = getNodeData;
exports.getNodeType = getNodeType;
exports.getChildren = getChildren;
exports.appendChildren = appendChildren;
exports.removeNode = removeNode;
exports.getAccessor = getAccessor;
exports.setAccessor = setAccessor;
exports.getNodeAttributes = getNodeAttributes;
exports.getRawNodeAttributes = getRawNodeAttributes;
var _constants = require('../constants');
var _util = require('../util');
var _hooks = require('../hooks');
// let ShittyMap = typeof WeakMap!=='undefined' ? WeakMap : (( map={}, counter=0 ) => ({
// set: (key, value) => {
// let id = key.__id || (key.__id = ++counter);
// map[id] = value;
// },
// get: key => key.__id!==undefined && map[key.__id]
// }));
//
// export const NODE_DATA = new ShittyMap();
//
// export function ensureNodeData(node) {
// let data = getNodeData(node);
// if (!data) NODE_DATA.set(node, data = {});
// return data;
// }
//
//
// export function getNodeData(node) {
// // try { return node[ATTR_KEY]; } catch (err) {}
// // if (node[ATTR_KEY]!==undefined) return node[ATTR_KEY];
// return NODE_DATA.get(node);
// }
function ensureNodeData(node) {
return getNodeData(node) || (node[_constants.ATTR_KEY] = {});
}
function setNodeData(node, data) {
node[_constants.ATTR_KEY] = data;
}
function getNodeData(node) {
// try { return node[ATTR_KEY]; } catch (err) {}
if (node[_constants.ATTR_KEY] !== undefined) return node[_constants.ATTR_KEY];
}
function getNodeType(node) {
if (node instanceof Text) return 3;
Eif (node instanceof Element) return 1;
return 0;
// if (node.normalizedNodeType!==undefined) return node.normalizedNodeType;
// // try { return node.nodeType|0; } catch (err) {}
// if (node.nodeType!==undefined) return node.nodeType|0;
}
function getChildren(node) {
// try { return node.childNodes; } catch (err) {}
Eif (node.childNodes !== undefined) return node.childNodes;
}
/** Append multiple children to a Node.
* Uses a Document Fragment to batch when appending 2 or more children
* @private
*/
function appendChildren(parent, children) {
var len = children.length,
many = len > 2,
into = many ? document.createDocumentFragment() : parent;
for (var i = 0; i < len; i++) {
into.appendChild(children[i]);
}Iif (many) parent.appendChild(into);
}
/** Removes a given DOM Node from its parent. */
function removeNode(node) {
var p = node.parentNode;
if (p) p.removeChild(node);
}
/** Retrieve the value of a rendered attribute
* @private
*/
function getAccessor(node, name) {
if (name !== 'type' && name !== 'style' && name !== 'key' && name in node) return node[name];
var attrs = getNodeData(node);
if (attrs && _util.hasOwnProperty.call(attrs, name)) return attrs[name];
if (name === 'class') return node.className || '';
if (name === 'style') return node.style.cssText || '';
// if (name!=='key') return node[name];
// return value;
}
/** Set a named attribute on the given Node, with special behavior for some names and event handlers.
* If `value` is `null`, the attribute/handler will be removed.
* @param {Element} node An element to mutate
* @param {string} name The name/key to set, such as an event or attribute name
* @param {any} value An attribute value, such as a function to be used as an event handler
* @param {any} previousValue The last value that was set for this name/node pair
* @private
*/
function setAccessor(node, name, value) {
if (name === 'class') {
node.className = value || '';
} else if (name === 'style') {
node.style.cssText = value || '';
} else if (name === 'dangerouslySetInnerHTML') {
if (value && value.__html) node.innerHTML = value.__html;
} else if (name === 'key') {} else if (name in node && name !== 'type') {
node[name] = value;
if (_util.falsey(value)) node.removeAttribute(name);
} else {
setComplexAccessor(node, name, value);
}
ensureNodeData(node)[name] = value;
}
/** For props without explicit behavior, apply to a Node as event handlers or attributes.
* @private
*/
function setComplexAccessor(node, name, value) {
if (name.substring(0, 2) === 'on') {
var _type = normalizeEventName(name),
l = node._listeners || (node._listeners = {}),
fn = !l[_type] ? 'add' : !value ? 'remove' : null;
if (fn) node[fn + 'EventListener'](_type, eventProxy);
l[_type] = value;
return;
}
var type = typeof value;
if (_util.falsey(value)) {
node.removeAttribute(name);
} else if (type !== 'function' && type !== 'object') {
node.setAttribute(name, value);
}
}
/** Proxy an event to hooked event handlers
* @private
*/
function eventProxy(e) {
var fn = this._listeners[normalizeEventName(e.type)];
Eif (fn) return fn.call(this, _hooks.optionsHook('event', e) || e);
}
/** Convert an Event name/type to lowercase and strip any "on*" prefix.
* @function
* @private
*/
var normalizeEventName = _util.memoize(function (t) {
return t.replace(/^on/i, '').toLowerCase();
});
/** Get a hashmap of node properties, preferring preact's cached property values over the DOM's
* @private
*/
function getNodeAttributes(node) {
return getNodeData(node) || getRawNodeAttributes(node) || _constants.EMPTY;
// let list = getRawNodeAttributes(node),
// l = node[ATTR_KEY];
// return l && list ? extend(list, l) : (l || list || EMPTY);
}
/** Get a node's attributes as a hashmap, regardless of type.
* @private
*/
function getRawNodeAttributes(node) {
var list = node.attributes;
Iif (!list || !list.getNamedItem) return list;
return getAttributesAsObject(list);
}
/** Convert a DOM `.attributes` NamedNodeMap to a hashmap.
* @private
*/
function getAttributesAsObject(list) {
var attrs = undefined;
for (var i = list.length; i--;) {
var item = list[i];
Eif (!attrs) attrs = {};
attrs[item.name] = item.value;
}
return attrs;
}
|